package com.shangguosha.model.skills;

import com.shangguosha.model.Character;
import com.shangguosha.model.Card;
import com.shangguosha.model.Skill;
import com.shangguosha.model.enums.SkillType;
import com.shangguosha.model.enums.EventType;
import com.shangguosha.core.event.GameEvent;
import lombok.extern.slf4j.Slf4j;

import java.util.HashSet;
import java.util.Set;

/**
 * 仁德技能
 * 出牌阶段，你可以将任意数量的手牌交给其他角色，然后你于此回合内不能再对其他角色使用【杀】。
 */
@Slf4j
public class RenDe extends Skill {
    
    private Set<Character> givenTargets; // 本回合已给予卡牌的角色
    private int cardsGivenThisTurn; // 本回合给予的卡牌数量
    private boolean usedThisTurn; // 本回合是否使用过仁德
    
    public RenDe(String id, Character owner) {
        super(id, "仁德", SkillType.ACTIVE,
                "出牌阶段，你可以将任意数量的手牌交给其他角色，然后你于此回合内不能再对其他角色使用【杀】。",
               1);
        this.givenTargets = new HashSet<>();
        this.cardsGivenThisTurn = 0;
        this.usedThisTurn = false;
    }
    
    public boolean canUse(Character user, Character target) {
        // 必须是技能拥有者使用
        if (user != getOwner()) {
            return false;
        }
        
        // 必须有手牌
        if (user.getHandCards().isEmpty()) {
            return false;
        }
        
        // 必须有其他存活角色作为目标
        if (target == null || target == user || !target.isAlive()) {
            return false;
        }
        
        // 检查游戏阶段（应该在出牌阶段）
//        if (user.getGameContext() != null) {
//            return user.getGameContext().getCurrentPhase().name().equals("PLAY");
//        }
        
        return true;
    }
    
    public void use(Character user, Character target) {
        if (!canUse(user, target)) {
            log.warn("仁德技能使用条件不满足");
            return;
        }
        
        // 标记本回合已使用仁德
        usedThisTurn = true;
        givenTargets.add(target);
        
        // 发送技能使用事件
//        if (user.getGameContext() != null && user.getGameContext().getEventBus() != null) {
//            GameEvent event = new GameEvent("skill_rende_used", user);
//            event.setProperty("target", target);
//            event.setProperty("skill", this);
//            user.getGameContext().getEventBus().emit(event);
//        }
//
        log.info("{} 对 {} 使用了仁德技能", user.getName(), target.getName());
    }
    
    /**
     * 当给予卡牌时触发
     */
    public void onCardGiven(Character target, Card card) {
        cardsGivenThisTurn++;
        givenTargets.add(target);
        
        log.info("仁德：{} 将 {} 给予 {}，本回合已给予 {} 张卡牌", 
                getOwner().getName(), card.getName(), target.getName(), cardsGivenThisTurn);
        
        // 发送卡牌给予事件
//        if (getOwner().getGameContext() != null && getOwner().getGameContext().getEventBus() != null) {
//            GameEvent event = new GameEvent("rende_card_given", getOwner());
//            event.setProperty("target", target);
//            event.setProperty("card", card);
//            event.setProperty("cardsGivenThisTurn", cardsGivenThisTurn);
//            getOwner().getGameContext().getEventBus().emit(event);
//        }
    }
    
    /**
     * 检查是否可以对目标使用杀
     */
    public boolean canUseKillOnTarget(Character target) {
        // 如果本回合使用过仁德，则不能对其他角色使用杀
        if (usedThisTurn && target != getOwner()) {
            log.info("仁德限制：{} 本回合使用过仁德，不能对 {} 使用杀", getOwner().getName(), target.getName());
            return false;
        }
        return true;
    }
    
    /**
     * 获取本回合给予的卡牌数量
     */
    public int getCardsGivenThisTurn() {
        return cardsGivenThisTurn;
    }
    
    /**
     * 获取本回合给予过卡牌的角色
     */
    public Set<Character> getGivenTargets() {
        return new HashSet<>(givenTargets);
    }
    
    /**
     * 检查本回合是否使用过仁德
     */
    public boolean isUsedThisTurn() {
        return usedThisTurn;
    }

    
    /**
     * 重置回合状态
     */
    private void resetTurnState() {
        givenTargets.clear();
        cardsGivenThisTurn = 0;
        usedThisTurn = false;
        log.debug("仁德技能状态已重置");
    }
    
    @Override
    public void resetUsage() {
        super.resetUsage();
        resetTurnState();
    }

    @Override
    public boolean canUse(Character user, Object... params) {
        return false;
    }

    @Override
    public void use(Character user, Object... params) {

    }

    @Override
    public String getEffectDescription() {
        if (usedThisTurn) {
            return String.format("本回合已使用仁德，给予了 %d 张卡牌，不能对其他角色使用【杀】", cardsGivenThisTurn);
        }
        return "可以将手牌给予其他角色，但本回合内不能对其他角色使用【杀】";
    }
    
    @Override
    public RenDe clone() {
        RenDe cloned = new RenDe(getId() + "_clone", getOwner());
        cloned.usedThisTurn = this.usedThisTurn;
        cloned.cardsGivenThisTurn = this.cardsGivenThisTurn;
        cloned.givenTargets = new HashSet<>(this.givenTargets);
        return cloned;
    }
}